package o;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import java.util.Collection;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class ds<K, V> extends dy<K, V> implements Map<K, V> {
    @Nullable
    dv<K, V> ˏ;

    public ds(int i) {
        super(i);
    }

    public ds(dy dyVar) {
        super(dyVar);
    }

    private dv<K, V> ˊ() {
        if (this.ˏ == null) {
            this.ˏ = new dv<K, V>(this) {
                final /* synthetic */ ds ˋ;

                {
                    this.ˋ = r1;
                }

                protected int ˋ() {
                    return this.ˋ.ʽ;
                }

                protected Object ॱ(int i, int i2) {
                    return this.ˋ.ʼ[(i << 1) + i2];
                }

                protected int ॱ(Object obj) {
                    return this.ˋ.ˎ(obj);
                }

                protected int ˏ(Object obj) {
                    return this.ˋ.ˏ(obj);
                }

                protected Map<K, V> ˊ() {
                    return this.ˋ;
                }

                protected void ˊ(K k, V v) {
                    this.ˋ.put(k, v);
                }

                protected V ˋ(int i, V v) {
                    return this.ˋ.ॱ(i, v);
                }

                protected void ˎ(int i) {
                    this.ˋ.ˏ(i);
                }

                protected void ॱ() {
                    this.ˋ.clear();
                }
            };
        }
        return this.ˏ;
    }

    public void putAll(Map<? extends K, ? extends V> map) {
        ˊ(this.ʽ + map.size());
        for (Entry entry : map.entrySet()) {
            put(entry.getKey(), entry.getValue());
        }
    }

    public boolean ˋ(@NonNull Collection<?> collection) {
        return dv.ˏ((Map) this, (Collection) collection);
    }

    public Set<Entry<K, V>> entrySet() {
        return ˊ().ˎ();
    }

    public Set<K> keySet() {
        return ˊ().ˏ();
    }

    public Collection<V> values() {
        return ˊ().ॱॱ();
    }
}
